home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / c / datelib.exe / WREADTIM.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-27  |  9.9 KB  |  301 lines
  1. static char wreadtime_prg1[] =
  2. "@(#)char *wreadtimew(WINDOW *win,int f, char *tstr) - Zeit einlesen (Curses-win)";
  3. static char wreadtime_prg2[] =
  4. "@(#)char *readtimew(int f, char *tstr) - Zeit einlesen (Curses-stdscr)";
  5. static char readtime_ver[]  = "@(#)v1.00/kr ; 01.08.91";
  6. /* wreadtimew       Einlesen eines Zeit-String unter Curses
  7. **
  8. ** Autor            Klaus Rath
  9. **
  10. ** Deklaration      char *wreadtimew(WINDOW *win,int format,char *timestring);
  11. **                  char *readtimew(int format, char *timestring);
  12. **
  13. ** Compilation      DOS:  bcc -c readtime.c c:\usr\local\lib\libkrc_s.lib
  14. **                  UNIX: cc  -c readtime.c /u1/usr/lib/libkrc.a
  15. **                  ( unter DOS kann die Funktion im small-Modell laufen )
  16. **
  17. ** Übergabe         Die Funktion erwartet einen Integer, der angibt in wel-
  18. **                  chem Format eingelesen werden soll.
  19. **                  Z.Zt. erlaubte Formate (siehe datum.h) :
  20. **                  hh:mm[:ss] -- Formate 1,2
  21. **                  hh.mm[.ss] -- Formate 3,4
  22. **                  hhmm[ss]   -- Datenbankformate 5,6 (DDB/4)
  23. **                  Außerdem wird ein Zeiger auf ein char-Array zur Aufnahme
  24. **                  des Ergebnisses erwartet.
  25. **
  26. ** Rückgabe         (char *) auf timestring
  27. **
  28. ** Anmerkungen      Die Funktion prüft nicht die Validität der eingegebenen
  29. **                  Zeit - dies sollte die aufrufende Funktion selbst tun,
  30. **                  bzw. den Test durch checktime() durchführen lassen.
  31. **                  Die Funktion benutzt zum Einlesen wgetch(win).
  32. **                  wreadtime() stellt dem Aufrufer eine Maske des angeforder-
  33. **                  ten Format zur Verfügung ( z.B. __:__:__ ), wobei die
  34. **                  Unterstriche durch Zahlen gefüllt werden müssen. Die
  35. **                  u.U. nötigen Trennzeichen sind im Gegensatz zu den Zahlen
  36. **                  nicht editierbar und werden automatisch erzeugt. Eine
  37. **                  Korrektur der Zahlen ist über die BACKSPACE-Taste möglich.
  38. **                  Die Eingabe von RETURN oder ESCAPE beendet die Eingabe
  39. **                  immer, hinter der letzten Position genügt ein beliebiges
  40. **                  Tastendruck dafür - außer BACKSPACE, wg. Korrektur.
  41. **
  42. ** Änderungen       1.00 ; 01.08.91
  43. **                  - Erste Version für CURSES, basiert auf Version 1.10 von
  44. **                    readtime()
  45. **                  1.01 ; 12.12.91
  46. **                  - Einlesefehler beseitigt: obwohl für ein WINDOW *win
  47. **                    konzipiert, wurde in wreadtime() mit getch() gelesen.
  48. */
  49.  
  50. #include <curses.h>
  51. #include <stdio.h>
  52. #include <string.h>
  53. #ifdef __TURBOC__
  54. #define ANSI
  55. #define KR_SYS
  56. #include <stdlib.h>
  57. #include "datum.h"
  58. #include "util.h"
  59. #else
  60. #include "/u1/usr/include/datum.h"
  61. #include "/u1/usr/include/util.h"
  62. #endif
  63.  
  64. #ifdef ANSI
  65. char *wreadtimew(WINDOW *win,int format, char *tstring)
  66. #else
  67. char *wreadtimew(win,format,tstring)
  68. WINDOW *win;
  69. int     format;
  70. char   *tstring;
  71. #endif
  72. {
  73.     /* Variablendefinitionen :
  74.     */
  75.     int trennpos1 = 2,                       /* Positionen von Trennzeichen */
  76.         trennpos2 = 5;
  77.     int trenner;                             /* das Trennzeichen            */
  78.     int pos       = 0;                       /* Aktuelle Position           */
  79.     int maxpos    = 11;                      /* Letztmögliche Position      */
  80.     int Max       = 0;                       /* Schalter, ob am Ende        */
  81.     int ch;                                  /* Einzulesendes Zeichen       */
  82.     int def_char  = '0';                     /* Default-Character           */
  83.  
  84.     /* Evtl. 1. Zeichen berücksichtigen :
  85.     */
  86.     if ( tstring[0] == NULL ) {
  87.         tstring[0] = def_char;
  88.     }
  89.     else {
  90.         pos = 1;
  91.     }
  92.  
  93.     /* Format überprüfen, String vorbelegen, Anzeigemaske erzeugen :
  94.     */
  95.     switch ( format ) {
  96.         case TI_HM_D :
  97.             trenner            = ':';
  98.             maxpos             = 6;
  99.             tstring[trennpos1] = trenner;
  100.             tstring[1]         =
  101.             tstring[3]         =
  102.             tstring[4]         = def_char;
  103.             tstring[5]         = '\0';
  104.             trennpos2          = 99;
  105.             wprintw(win,"%c0:00",tstring[0]);
  106.             wprintw(win,"\b\b\b\b");
  107.             break;
  108.         case TI_HM_P :
  109.             trenner            = '.';
  110.             maxpos             = 6;
  111.             tstring[trennpos1] = trenner;
  112.             tstring[1]         =
  113.             tstring[3]         =
  114.             tstring[4]         = def_char;
  115.             tstring[5]         = '\0';
  116.             trennpos2          = 99;
  117.             wprintw(win,"%c0.00",tstring[0]);
  118.             wprintw(win,"\b\b\b\b");
  119.             break;
  120.         case TI_HMS_P :
  121.             trenner            = '.';
  122.             maxpos             = 9;
  123.             tstring[trennpos1] =
  124.             tstring[trennpos2] = trenner;
  125.             tstring[1]         =
  126.             tstring[3]         =
  127.             tstring[4]         =
  128.             tstring[6]         =
  129.             tstring[7]         = def_char;
  130.             tstring[8]         = '\0';
  131.             wprintw(win,"%c0.00.00",tstring[0]);
  132.             wprintw(win,"\b\b\b\b\b\b\b");
  133.             break;
  134.         case TI_HM_DB :
  135.             maxpos             = 5;
  136.             tstring[1]         =
  137.             tstring[2]         =
  138.             tstring[3]         = def_char;
  139.             tstring[4]         = '\0';
  140.             trennpos1          =
  141.             trennpos2          = 99;
  142.             wprintw(win,"%c000",tstring[0]);
  143.             wprintw(win,"\b\b\b");
  144.             break;
  145.         case TI_HMS_DB :
  146.             maxpos             = 7;
  147.             tstring[1]         =
  148.             tstring[2]         =
  149.             tstring[3]         =
  150.             tstring[4]         =
  151.             tstring[5]         = def_char;
  152.             tstring[6]         = '\0';
  153.             trennpos1          =
  154.             trennpos2          = 99;
  155.             wprintw(win,"%c00000",tstring[0]);
  156.             wprintw(win,"\b\b\b\b\b");
  157.             break;
  158.         case TI_HMS_D :
  159.         default :
  160.             trenner            = ':';
  161.             maxpos             = 9;
  162.             tstring[trennpos1] =
  163.             tstring[trennpos2] = trenner;
  164.             tstring[1]         =
  165.             tstring[3]         =
  166.             tstring[4]         =
  167.             tstring[6]         =
  168.             tstring[7]         = def_char;
  169.             tstring[8]         = '\0';
  170.             wprintw(win,"%c0:00:00",tstring[0]);
  171.             wprintw(win,"\b\b\b\b\b\b\b");
  172.             break;
  173.     } /* ENDE: switch(format) */
  174.  
  175.     /* Evtl. noch ein Rückschritt :
  176.     */
  177.     if ( !pos ) {
  178.         wprintw(win,"\b");
  179.     }
  180.     wrefresh(win);
  181.  
  182.     /* Tastendrucke abholen, bis maxpos :
  183.     */
  184.     while ( pos < maxpos + 1 ) {
  185.  
  186.         if ( pos == 0 ) {
  187.             tstring[pos] = def_char;
  188.         }
  189.         wrefresh(win);
  190.  
  191.         /* Falls fertig, String zurückgeben :
  192.         */
  193.         if ( pos == maxpos ) {
  194.             tstring[pos] = '\0';
  195.             return(tstring);
  196.         }
  197.         /* An eventuellen Trennerpositionen den passenden Trenner einfügen
  198.         ** und den nächsten Schleifendurchlauf abwarten :
  199.         */
  200.         if ( pos == trennpos1 || pos == trennpos2 ) {
  201.             wprintw(win,"%c",trenner);
  202.             wrefresh(win);
  203.             pos++;
  204.             continue;
  205.         }
  206.         /* An der vorletzten Position sind alle Tasten erlaubt, denn nur
  207.         ** BACKSPACE bleibt in der Funktion :
  208.         */
  209.         if ( pos == maxpos - 1 ) {
  210.             Max = 1;
  211.         }
  212.         ch  = wgetch(win);
  213.  
  214.         /* Auswertung der gedrückten Taste :
  215.         */
  216.         switch ( ch ) {
  217.  
  218.             /* Nicht Zulässiges ignorieren :
  219.             */
  220.             case NULL:
  221.             case -1  :
  222.                 break;
  223.  
  224.             /* Abbruchmöglichkeiten :
  225.             */
  226.             case 27  :
  227.                 tstring[0] = '\0';
  228.                 return(tstring);
  229.             case 10  :
  230.             case 13  :
  231.                 tstring[maxpos-1] = '\0';
  232.                 return(tstring);
  233.  
  234.             /* Korrekturmöglichkeit :
  235.             */
  236.             case  8  :
  237.                 if ( pos == 0 ) {
  238.                 break;
  239.                     }
  240.                 tstring[pos] = def_char;
  241.  
  242.                 /* Schalter für MAX-Position zurücksetzen :
  243.                 */
  244.                 if ( Max )
  245.                     Max = 0;
  246.  
  247.                 /* Trenner überspringen und Maskendefault anzeigen :
  248.                 */
  249.                 if ( pos == trennpos1 + 1 || pos == trennpos2 + 1 ) {
  250.                     wprintw(win,"\b\b%c\b",def_char);
  251.                     wrefresh(win);
  252.                     pos -= 2;
  253.                     break;
  254.                 }
  255.  
  256.                 /* Ansonsten zurück und Maskendefault anzeigen :
  257.                 */
  258.                 if ( pos ) {
  259.                     pos--;
  260.                 }
  261.                 wprintw(win,"\b%c\b",def_char);
  262.                 wrefresh(win);
  263.                 break;
  264.  
  265.             default  :
  266.                 /* Falls wir fertig sind, String abschließen und
  267.                 ** zurückgeben :
  268.                 */
  269.                 if ( Max ) {
  270.                     tstring[pos] = '\0';
  271.                     return(tstring);
  272.                 }
  273.  
  274.                 /* Ansonsten ist es eine Zahl, die angezeigt und ein-
  275.                 ** getragen wird :
  276.                 */
  277.                 if ( ch > '9' || ch < '0' ) {
  278.                     break;
  279.                 }
  280.                 wprintw(win,"%c",ch);
  281.                 wrefresh(win);
  282.                 tstring[pos] = ch;
  283.                 pos++;
  284.  
  285.         } /* ENDE: switch(ch) */
  286.     } /* ENDE: while(pos) */
  287.  
  288.     return(tstring);
  289.  
  290. } /* ENDE: wreadtimew() */
  291.  
  292. /* Version für stdscr :
  293. */
  294. char *readtimew(format,tstring)
  295. int  format;
  296. char *tstring;
  297. {
  298.   wreadtimew(stdscr,format,tstring);
  299.   return(tstring);
  300. } /* ENDE: readtimew() */
  301.